notebooks/Solve Synthetic Tides.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solve Synthetic Tides\n",
    "=====================\n",
    "\n",
    "Solves for the harmonic constants for a tidal time series\n",
    "\n",
    "#### Python Dependencies\n",
    " - [numpy: Scientific Computing Tools For Python](https://www.numpy.org)  \n",
    " - [scipy: Scientific Tools for Python](https://www.scipy.org/)  \n",
    " - [pyproj: Python interface to PROJ library](https://pypi.org/project/pyproj/)  \n",
    " - [netCDF4: Python interface to the netCDF C library](https://unidata.github.io/netcdf4-python/)  \n",
    " - [matplotlib: Python 2D plotting library](https://matplotlib.org/)  \n",
    " - [ipyleaflet: Jupyter / Leaflet bridge enabling interactive maps](https://github.com/jupyter-widgets/ipyleaflet)  \n",
    "\n",
    "#### Program Dependencies\n",
    "\n",
    "- `arguments.py`: load the nodal corrections for tidal constituents  \n",
    "- `astro.py`: computes the basic astronomical mean longitudes  \n",
    "- `crs.py`: Coordinate Reference System (CRS) routines  \n",
    "- `io.model.py`: retrieves tide model parameters for named tide models\n",
    "- `io.OTIS.py`: extract tidal harmonic constants from OTIS tide models  \n",
    "- `io.ATLAS.py`: extract tidal harmonic constants from ATLAS netCDF4 tide models  \n",
    "- `io.GOT.py`: extract tidal harmonic constants from GOT tide models  \n",
    "- `io.FES.py`: extract tidal harmonic constants from FES tide models  \n",
    "- `io.constituents.py`: basic tide model constituent class  \n",
    "- `predict.py`: predict tidal values using harmonic constants  \n",
    "- `solve.py`: estimates the harmonic constants for ocean tides\n",
    "- `time.py`: utilities for calculating time operations\n",
    "- `utilities.py`: download and management utilities for files\n",
    "\n",
    "This notebook uses Jupyter widgets to set parameters for calculating the tidal maps.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import IPython.display\n",
    "import ipywidgets\n",
    "\n",
    "# import tide programs\n",
    "import pyTMD.io\n",
    "import pyTMD.time\n",
    "import pyTMD.predict\n",
    "import pyTMD.solve\n",
    "import pyTMD.tools\n",
    "import pyTMD.utilities\n",
    "\n",
    "# autoreload\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# available model list\n",
    "model_list = sorted(pyTMD.io.model.ocean_elevation())\n",
    "# display widgets for setting directory and model\n",
    "TMDwidgets = pyTMD.tools.widgets()\n",
    "TMDwidgets.model.options = model_list\n",
    "TMDwidgets.model.value = 'GOT4.10'\n",
    "TMDwidgets.VBox([\n",
    "    TMDwidgets.directory,\n",
    "    TMDwidgets.model,\n",
    "    TMDwidgets.atlas,\n",
    "    TMDwidgets.compress,\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default coordinates to use\n",
    "LAT,LON = (-76.0, -40.0)\n",
    "m = pyTMD.tools.leaflet(center=(LAT,LON), zoom=3,\n",
    "    zoom_control=True, marker_control=True)\n",
    "# show map\n",
    "m.map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HTML table with outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table = ipywidgets.HTML()\n",
    "display(table)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get model parameters\n",
    "model = pyTMD.io.model(TMDwidgets.directory.value,\n",
    "    format=TMDwidgets.atlas.value,\n",
    "    compressed=TMDwidgets.compress.value\n",
    "   ).elevation(TMDwidgets.model.value)\n",
    "\n",
    "# convert time to days relative to Jan 1, 1992 (48622 MJD)\n",
    "minutes = np.arange(366*1440)\n",
    "tide_time = pyTMD.time.convert_calendar_dates(2000, 1, 1, minute=minutes)\n",
    "\n",
    "# delta time (TT - UT1) file\n",
    "delta_file = pyTMD.utilities.get_data_path(['data','merged_deltat.data'])\n",
    "\n",
    "# read tidal constants and interpolate to leaflet points\n",
    "if model.format in ('OTIS','ATLAS','TMD3'):\n",
    "    constituents = pyTMD.io.OTIS.read_constants(\n",
    "        model.grid_file, model.model_file,\n",
    "        model.projection, type=model.type,\n",
    "        grid=model.format)\n",
    "    c = constituents.fields\n",
    "    DELTAT = np.zeros_like(tide_time)\n",
    "elif (model.format == 'netcdf'):\n",
    "    constituents = pyTMD.io.ATLAS.read_constants(\n",
    "        model.grid_file, model.model_file,\n",
    "        type=model.type, compressed=model.compressed)\n",
    "    c = constituents.fields\n",
    "    DELTAT = np.zeros_like(tide_time)\n",
    "elif (model.format == 'GOT'):\n",
    "    constituents = pyTMD.io.GOT.read_constants(\n",
    "        model.model_file, compressed=model.compressed)\n",
    "    c = constituents.fields\n",
    "    # interpolate delta times from calendar dates to tide time\n",
    "    DELTAT = pyTMD.time.interpolate_delta_time(delta_file, tide_time)\n",
    "elif (model.format == 'FES'):\n",
    "    constituents = pyTMD.io.FES.read_constants(model.model_file,\n",
    "        type=model.type, version=model.version,\n",
    "        compressed=model.compressed)\n",
    "    c = model.constituents\n",
    "    # interpolate delta times from calendar dates to tide time\n",
    "    DELTAT = pyTMD.time.interpolate_delta_time(delta_file, tide_time)\n",
    "\n",
    "# update the tide solution\n",
    "def update_tide_solution(*args):\n",
    "    # leaflet location\n",
    "    LAT,LON = np.copy(m.marker.location)\n",
    "    # verify longitudes\n",
    "    LON = m.wrap_longitudes(LON)\n",
    "    if model.format in ('OTIS','ATLAS','TMD3'):\n",
    "        amp,ph,D = pyTMD.io.OTIS.interpolate_constants(\n",
    "            np.atleast_1d(LON), np.atleast_1d(LAT),\n",
    "            constituents, model.projection, type=model.type,\n",
    "            method='spline', extrapolate=True)\n",
    "    elif (model.format == 'netcdf'):\n",
    "        amp,ph,D = pyTMD.io.ATLAS.interpolate_constants(\n",
    "            np.atleast_1d(LON), np.atleast_1d(LAT),\n",
    "            constituents, type=model.type, scale=model.scale,\n",
    "            method='spline', extrapolate=True)\n",
    "    elif (model.format == 'GOT'):\n",
    "        amp,ph = pyTMD.io.GOT.interpolate_constants(\n",
    "            np.atleast_1d(LON), np.atleast_1d(LAT),\n",
    "            constituents, scale=model.scale,\n",
    "            method='spline', extrapolate=True)\n",
    "    elif (model.format == 'FES'):\n",
    "        amp,ph = pyTMD.io.FES.interpolate_constants(\n",
    "            np.atleast_1d(LON), np.atleast_1d(LAT),\n",
    "            constituents, scale=model.scale,\n",
    "            method='spline', extrapolate=True)\n",
    "    # calculate complex phase in radians for Euler's\n",
    "    cph = -1j*ph*np.pi/180.0\n",
    "    # calculate constituent oscillation\n",
    "    hc = amp*np.exp(cph)\n",
    "    # predict tidal elevations at time 1 and infer minor corrections\n",
    "    TIDE = pyTMD.predict.time_series(tide_time, hc, c,\n",
    "        deltat=DELTAT, corrections=model.format)\n",
    "    MINOR = pyTMD.predict.infer_minor(tide_time, hc, c,\n",
    "        deltat=DELTAT, corrections=model.format)\n",
    "    TIDE.data[:] += MINOR.data[:]\n",
    "\n",
    "    # solve for harmonic constants\n",
    "    famp, fph = pyTMD.solve.constants(tide_time, TIDE.data, c,\n",
    "        deltat=DELTAT, corrections=model.format)\n",
    "\n",
    "    # create a HTML table with values\n",
    "    # HTML table header\n",
    "    table.value = \"\"\"<table>\n",
    "\t\t<thead>\n",
    "\t\t<tr>\n",
    "\t\t\t<th style=\"text-align:center; padding: 10px\">Constituent</th>\n",
    "\t\t\t<th style=\"text-align:center; padding: 10px\">Original Amplitude</th>\n",
    "\t\t\t<th style=\"text-align:center; padding: 10px\">Original Phase</th>\n",
    "\t\t\t<th style=\"text-align:center; padding: 10px\">Solution Amplitude</th>\n",
    "\t\t\t<th style=\"text-align:center; padding: 10px\">Solution Phase</th>\n",
    "\t\t</tr>\n",
    "\t\t</thead>\n",
    "\t\t<tbody>\n",
    "    \"\"\"\n",
    "    # print the original and solution amplitudes and phases to table\n",
    "    for i,con in enumerate(c):\n",
    "        table.value += f\"\"\"\n",
    "            <tr>\n",
    "\t\t\t    <td style=\"text-align:center\">{con}</td>\n",
    "\t\t\t    <td style=\"text-align:center\">{100*amp.data[0,i]:0.1f}cm</td>\n",
    "                <td style=\"text-align:center\">{ph.data[0,i]:0.1f}\\u00b0</td>\n",
    "\t\t\t    <td style=\"text-align:center\">{100*famp[i]:0.1f}cm</td>\n",
    "                <td style=\"text-align:center\">{fph[i]:0.1f}\\u00b0</td>\n",
    "            </tr>\n",
    "        \"\"\"\n",
    "    # close HTML table\n",
    "    table.value += \"\"\"\n",
    "        </tbody>\n",
    "    </table>\n",
    "    \"\"\"\n",
    "\n",
    "# run tide prediction and solution at initial location\n",
    "update_tide_solution()\n",
    "# watch marker location for changes\n",
    "m.marker_text.observe(update_tide_solution)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}